package cn.org.xwb.bookmall.model.utils;

import cn.org.xwb.bookmall.model.constant.AccountConst;
import cn.org.xwb.bookmall.model.constant.LoginConst;
import cn.org.xwb.bookmall.model.po.Manager;
import cn.org.xwb.bookmall.model.po.User;
import cn.org.xwb.bookmall.model.po.UserAllInfo;
import cn.org.xwb.bookmall.model.properties.AccountProp;
import cn.org.xwb.bookmall.model.properties.MailProp;
import cn.org.xwb.bookmall.model.properties.RedisProp;
import cn.org.xwb.common.redis.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BookRedisUtil {

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private RedisProp redisProp;

    @Autowired
    private AccountProp accountProp;

    @Autowired
    private MailProp mailProp;

    /**
     * 获取用户相关的 redis key
     *
     * @param pre
     * @param suf
     * @return
     */
    public String getRedisKeyUser(String pre, String suf) {
        return redisProp.getRedisKeyUser(pre.formatted(suf));
    }

    /**
     * 获取缓存的用户登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public String getLoginMailCodeUser(String mail) {
        return redisUtil.getStr(getRedisKeyUser(LoginConst.LOGIN_MAIL_CODE, mail));
    }

    /**
     * 缓存用户登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public Boolean cacheLoginMailCodeUser(String mail, String code) {
        return redisUtil.setVal(
                getRedisKeyUser(LoginConst.LOGIN_MAIL_CODE, mail),
                code,
                mailProp.getCodeExpire(),
                mailProp.getCodeExpireUnit()
        );
    }

    /**
     * 获取缓存的用户是否可以再次获取登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public String getLoginMailCodeAgainUser(String mail) {
        return redisUtil.getStr(getRedisKeyUser(LoginConst.LOGIN_MAIL_CODE_AGAIN, mail));
    }

    /**
     * 缓存用户是否可以再次获取登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public Boolean cacheLoginMailCodeAgainUser(String mail, String code) {
        return redisUtil.setVal(
                getRedisKeyUser(LoginConst.LOGIN_MAIL_CODE_AGAIN, mail),
                code,
                mailProp.getCodeAgain(),
                mailProp.getCodeExpireUnit()
        );
    }

    /**
     * 缓存用户账号信息
     *
     * @param user
     * @return true-成功；false-失败
     */
    public Boolean cacheUser(User user) {
        return redisUtil.setVal(
                getRedisKeyUser(AccountConst.ACCOUNT, user.getAccount()),
                user,
                accountProp.getAccountCacheExpireUser(),
                accountProp.getAccountCacheExpireUserUnit()
        );
    }

    /**
     * 缓存用户账号信息
     *
     * @param user
     * @return true-成功；false-失败
     */
    public Boolean cacheUser(UserAllInfo user) {
        return redisUtil.setVal(
                getRedisKeyUser(AccountConst.ACCOUNT, user.getAccount()),
                user,
                accountProp.getAccountCacheExpireUser(),
                accountProp.getAccountCacheExpireUserUnit()
        );
    }

    /**
     * 清除缓存的用户账号信息
     *
     * @param account
     * @return true-成功；false-失败
     */
    public Object cacheUser(String account) {
        return redisUtil.getAndDel(getRedisKeyUser(AccountConst.ACCOUNT, account));
    }

    /**
     * 清除缓存的用户账号信息
     *
     * @param account
     * @return true-成功；false-失败
     */
    public Object delCacheUser(String account) {
        return redisUtil.getAndDel(getRedisKeyUser(AccountConst.ACCOUNT, account));
    }

    /**
     * 获取并刷新用户账号缓存信息
     *
     * @param account
     * @return
     */
    public UserAllInfo getAndResetExpireUser(String account) {
        return (UserAllInfo) redisUtil.getAndResetExpire(
                getRedisKeyUser(AccountConst.ACCOUNT, account),
                accountProp.getAccountCacheExpireUser(),
                accountProp.getAccountCacheExpireUserUnit()
        );
    }

    /**
     * 获取管理员相关的 redis key
     *
     * @param pre
     * @param suf
     * @return
     */
    public String getRedisKeyAdmin(String pre, String suf) {
        return redisProp.getRedisKeyAdmin(pre.formatted(suf));
    }

    /**
     * 获取缓存的管理员登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public String getLoginMailCodeAdmin(String mail) {
        return redisUtil.getStr(getRedisKeyAdmin(LoginConst.LOGIN_MAIL_CODE, mail));
    }

    /**
     * 缓存管理员登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public Boolean cacheLoginMailCodeAdmin(String mail, String code) {
        return redisUtil.setVal(
                getRedisKeyAdmin(LoginConst.LOGIN_MAIL_CODE, mail),
                code,
                mailProp.getCodeExpire(),
                mailProp.getCodeExpireUnit()
        );
    }

    /**
     * 获取缓存的管理员是否可以再次获取登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public String getLoginMailCodeAgainAdmin(String mail) {
        return redisUtil.getStr(getRedisKeyAdmin(LoginConst.LOGIN_MAIL_CODE_AGAIN, mail));
    }

    /**
     * 缓存管理员是否可以再次获取登录邮箱验证码
     *
     * @param mail
     * @return
     */
    public Boolean cacheLoginMailCodeAgainAdmin(String mail, String code) {
        return redisUtil.setVal(
                getRedisKeyAdmin(LoginConst.LOGIN_MAIL_CODE_AGAIN, mail),
                code,
                mailProp.getCodeAgain(),
                mailProp.getCodeExpireUnit()
        );
    }

    /**
     * 缓存管理员账号信息
     *
     * @param manager
     * @return true-成功；false-失败
     */
    public Boolean cacheManager(Manager manager) {
        return redisUtil.setVal(
                getRedisKeyAdmin(AccountConst.ACCOUNT, manager.getAccount()),
                manager,
                accountProp.getAccountCacheExpireAdmin(),
                accountProp.getAccountCacheExpireAdminUnit()
        );
    }

    /**
     * 清除缓存的管理员账号信息
     *
     * @param account
     * @return true-成功；false-失败
     */
    public Object delCacheManager(String account) {
        return redisUtil.getAndDel(getRedisKeyAdmin(AccountConst.ACCOUNT, account));
    }

    /**
     * 获取并刷新管理员账号缓存信息
     *
     * @param account
     * @return
     */
    public Manager getAndResetExpireAdmin(String account) {
        return (Manager) redisUtil.getAndResetExpire(
                getRedisKeyAdmin(AccountConst.ACCOUNT, account),
                accountProp.getAccountCacheExpireAdmin(),
                accountProp.getAccountCacheExpireAdminUnit()
        );
    }

}
